package demo;

import com.sun.org.apache.bcel.internal.generic.LSTORE;
import jdk.nashorn.internal.objects.annotations.Getter;
import jdk.nashorn.internal.objects.annotations.Setter;
import parent.C;
import parent.T;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * OptionalDemo
 *
 * @author dingwen
 * @date 2022/03/25
 */
public class OptionalDemo2 {
    public static void main(String[] args) {
        Cat cat = test();

        Optional<Cat> catOptional = Optional.ofNullable(cat);

//        Cat catResult = objectHandler(c -> c.setColor("red"), Cat::new, catOptional);

//        System.out.println("catResult = " + catResult);

        // 为空则抛出异常
//        Cat cat1 = catOptional.orElseThrow(RuntimeException::new);

        List<String> hobbyList = new ArrayList<>();
        hobbyList.add("fish");
        cat.setHobbyList(hobbyList);

        hobbyList.stream()
                .flatMap(str -> Arrays.stream(str.split("")))
                .forEach(System.out::println);


//        Integer integer = catOptional.map(c -> c.getName().length() > 0 ? 1 : 0).get();

//        Optional<Cat> catOptional1 = catOptional.filter(c3 -> c3.getColor().equals("red"));

//        Optional<String> s = catOptional.flatMap(name -> Optional.ofNullable(cat.getName()));
    }



    public static Cat test() {
        return new Cat();
//        return null;
    }

    /**
     * 对象处理
     *
     * @param consumer 默认实现
     * @param supplier 缺省实现
     * @param t        t
     * @return {@link T}
     */
    @SuppressWarnings("all")
    public static <T> T objectHandler(Consumer<? super T> consumer, Supplier<? extends T> supplier, Optional<T> t) {
        // 不为空实现 consumer
        t.ifPresent(consumer);
        // 缺省实现 supplier
        t = Optional.of(t.orElseGet(supplier));
        return t.get();
    }
}


class Cat implements Comparator<Cat> {
    String name;
    String color;
    List<String> hobbyList;

    public Cat() {
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", hobbyList=" + hobbyList +
                '}';
    }

    public List<String> getHobbyList() {
        return hobbyList;
    }

    public void setHobbyList(List<String> hobbyList) {
        this.hobbyList = hobbyList;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }


    /**
     * Compares its two arguments for order.  Returns a negative integer,
     * zero, or a positive integer as the first argument is less than, equal
     * to, or greater than the second.<p>
     * <p>
     * In the foregoing description, the notation
     * <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
     * <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
     * <tt>0</tt>, or <tt>1</tt> according to whether the value of
     * <i>expression</i> is negative, zero or positive.<p>
     * <p>
     * The implementor must ensure that <tt>sgn(compare(x, y)) ==
     * -sgn(compare(y, x))</tt> for all <tt>x</tt> and <tt>y</tt>.  (This
     * implies that <tt>compare(x, y)</tt> must throw an exception if and only
     * if <tt>compare(y, x)</tt> throws an exception.)<p>
     * <p>
     * The implementor must also ensure that the relation is transitive:
     * <tt>((compare(x, y)&gt;0) &amp;&amp; (compare(y, z)&gt;0))</tt> implies
     * <tt>compare(x, z)&gt;0</tt>.<p>
     * <p>
     * Finally, the implementor must ensure that <tt>compare(x, y)==0</tt>
     * implies that <tt>sgn(compare(x, z))==sgn(compare(y, z))</tt> for all
     * <tt>z</tt>.<p>
     * <p>
     * It is generally the case, but <i>not</i> strictly required that
     * <tt>(compare(x, y)==0) == (x.equals(y))</tt>.  Generally speaking,
     * any comparator that violates this condition should clearly indicate
     * this fact.  The recommended language is "Note: this comparator
     * imposes orderings that are inconsistent with equals."
     *
     * @param o1 the first object to be compared.
     * @param o2 the second object to be compared.
     * @return a negative integer, zero, or a positive integer as the
     * first argument is less than, equal to, or greater than the
     * second.
     * @throws NullPointerException if an argument is null and this
     *                              comparator does not permit null arguments
     * @throws ClassCastException   if the arguments' types prevent them from
     *                              being compared by this comparator.
     */
    @Override
    public int compare(Cat o1, Cat o2) {
        return 0;
    }
}


